﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OOLib
{
   /// <summary>
   /// allows to exclicitly free resources and break cyclic references. 
   /// </summary>
   /// <remarks>
   /// Actually the real lifetime of an UNO object is controlled by references kept on interfaces of this object. 
   /// But there are two distinct meanings in keeping a reference to an interface: 1st to own the object and 2nd to know the object. 
   /// You are only allowed to keep references of interfaces to UNO objects if you are by definition the owner of that object or 
   /// your reference is very temporary or you have registered an EventListener at that object and release the reference when "disposing" is called.
   /// </remarks>
   public class Component : ComObjectWrapper, IController
   {
      #region Constructors

      /// <summary>
      /// Constructor
      /// </summary>
      /// <remarks>
      /// After using this constructor, the ComObj must be set manually!
      /// </remarks>
      public Component() :
         base()
      { }

      /// <summary>
      /// Constructor
      /// </summary>
      /// <param name="comObject">COM object</param>
      public Component(object comObject) :
         base(comObject)
      { }

      #endregion

      /// <summary>
      /// The owner of an object calls this method to explicitly free all resources kept by this object and thus break cyclic references. 
      /// </summary>
      /// <remarks>
      /// Only the owner of this object is allowed to call this method. The object should release all resources and references 
      /// in the easiest possible manner ( for instance no serialization should take place anymore ). 
      /// The object must notify all registered listeners using the method XEventListener::disposing. 
      /// All notfied objects should release there references to this object without calling 
      /// XComponent::removeEventListener (the disposed object will release the listeners eitherway). 
      /// After this method has been called, the object should behave as passive as possible, thus it should ignore 
      /// all calls in case it can comply with its specification (for instance addEventListener()). Often the object 
      /// can't fulfill its specification anymore, in this case it must throw the DisposedException (which is derived 
      /// from ::com::sun::star::uno::RuntimeException) when it gets called.
      /// For some objects no real owner can be identified, thus it can be disposed from multiple reference holders. 
      /// In this case the object should be able to cope with multiple dispose()-calls (which are inevitable in a multithreaded environment). 
      /// </remarks>
      public void OODispose()
      {
         CheckDisposed();
         InvokeMethod("dispose");
      }
   }

   /// <summary>
   /// allows to exclicitly free resources and break cyclic references. 
   /// </summary>
   /// <remarks>
   /// Actually the real lifetime of an UNO object is controlled by references kept on interfaces of this object. 
   /// But there are two distinct meanings in keeping a reference to an interface: 1st to own the object and 2nd to know the object. 
   /// You are only allowed to keep references of interfaces to UNO objects if you are by definition the owner of that object or 
   /// your reference is very temporary or you have registered an EventListener at that object and release the reference when "disposing" is called.
   /// </remarks>
   public interface IController
   {
      /// <summary>
      /// The owner of an object calls this method to explicitly free all resources kept by this object and thus break cyclic references. 
      /// </summary>
      /// <remarks>
      /// Only the owner of this object is allowed to call this method. The object should release all resources and references 
      /// in the easiest possible manner ( for instance no serialization should take place anymore ). 
      /// The object must notify all registered listeners using the method XEventListener::disposing. 
      /// All notfied objects should release there references to this object without calling 
      /// XComponent::removeEventListener (the disposed object will release the listeners eitherway). 
      /// After this method has been called, the object should behave as passive as possible, thus it should ignore 
      /// all calls in case it can comply with its specification (for instance addEventListener()). Often the object 
      /// can't fulfill its specification anymore, in this case it must throw the DisposedException (which is derived 
      /// from ::com::sun::star::uno::RuntimeException) when it gets called.
      /// For some objects no real owner can be identified, thus it can be disposed from multiple reference holders. 
      /// In this case the object should be able to cope with multiple dispose()-calls (which are inevitable in a multithreaded environment). 
      /// </remarks>
      void OODispose();

      //todo support listeners
   }
}
